home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Action.c next >
C/C++ Source or Header  |  1996-05-04  |  17KB  |  699 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysAction.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    int StartAction ( int ftype , char *file , BOOL last );
  12.    *    void BuildActionList ( void );
  13.    *    void DisplayFileRequest ( void );
  14.    *
  15.    *      --- Lokale  Routinen ---
  16.    *
  17.    *    static long OpenActionWindow ( LIST *AL , BOOL last );
  18.    *    static void BuildActionEntry ( UBYTE *line , RSYS_acts *Act );
  19.    *    static void ShowInfo ( char *file );
  20.    *
  21.    * Bemerkungen:
  22.    *      Actioning-Routinen von RSys. Wird ein Icon auf das AppIcon von
  23.    *      RSys gezogen, werden entsprechend des Dateityps Aktionen
  24.    *      gestartet.
  25.    *
  26.    * Erstellungsdatum:
  27.    *      07-Jan-93     Rolf Böhme
  28.    *
  29.    * Änderungen:
  30.    *      07-Jan-93     Rolf Böhme        Erstellung
  31.    *
  32.    ***************************************************************************
  33.  */
  34.  
  35. #include "RSys.h"
  36. #include "protos.h"
  37.  
  38.  
  39.  /*
  40.   * Die Intuition-Objekte für den Aufbau des
  41.   * "Auswahl-Fensters der Aktionen".
  42.   */
  43. static WINDOW *ActionWnd = NULL;
  44. static GADGET *ActionGList = NULL;
  45. static GADGET *ActionGadgets[4];
  46. static UWORD ActionLeft = 211;
  47. static UWORD ActionTop = 43;
  48. static UWORD ActionWidth = 149;
  49. static UWORD ActionHeight;
  50. static UBYTE ActionWdt[14] = "Action";
  51.  
  52.  /*
  53.   * Die Funktion OpenActionWindow() öffnet ein Fenster
  54.   * mit einem ListView und zwei Gadgets. Im ListView
  55.   * werden die Aktionen zu einem erkannten Dateitypen
  56.   * angezeigt. Werden mehrere Dateien behandelt, so
  57.   * erscheint ein weiteres Gadget, mit dem man zur
  58.   * nächsten Datei wechseln kann.
  59.   */
  60. static long
  61. OpenActionWindow (LIST * AL, BOOL last)
  62. {
  63.   NEWGADGET ng;
  64.   GADGET *g;
  65.   UWORD wleft = ActionLeft, wtop = ActionTop, ww, wh;
  66.   int gl[] =
  67.   {GD_FileTypeTGad - GD_FileTypeTGad,
  68.    GD_ActionLV - GD_FileTypeTGad};
  69.  
  70.   ActionHeight = (last ? 92 : 108);
  71.  
  72.   AdjustWindowDimensions (Scr, ActionLeft, ActionTop, ActionWidth, ActionHeight,
  73.               &wleft, &wtop, &ww, &wh);
  74.  
  75.   /*
  76.    * Der Gadtools-Kontext dr Benutzeroberfläche wird
  77.    * erzeugt.
  78.    */
  79.   if (NOT (g = CreateContext (&ActionGList)))
  80.     return 1L;
  81.  
  82.   /*
  83.    * Der Reihe nach werden alle Gadgets des Fensters
  84.    * erzeugt und in den Kontext eingebunden. Dabei
  85.    * werden pro Gadget nur die Werte verändert, die
  86.    * sich gegenüber dem vorhergehenden gändert haben.
  87.    */
  88.   ng.ng_LeftEdge = compute (OffX, FontX, 4);
  89.   ng.ng_TopEdge = compute (OffY, FontY, 1);
  90.   ng.ng_Width = compute ((UWORD) 0, FontX, 141);
  91.   ng.ng_Height = compute ((UWORD) 0, FontY, 15);
  92.   ng.ng_GadgetText = NULL;
  93.   ng.ng_TextAttr = Font;
  94.   ng.ng_GadgetID = GD_FileTypeTGad;
  95.   ng.ng_Flags = 0;
  96.   ng.ng_VisualInfo = VisualInfo;
  97.  
  98.   g = CreateGadget (TEXT_KIND, g, &ng, GTTX_Text, NULL, GTTX_Border, TRUE, TAG_DONE);
  99.  
  100.   ActionGadgets[0] = g;
  101.  
  102.   ng.ng_TopEdge = compute (OffY, FontY, 17);
  103.   ng.ng_Height = compute ((UWORD) 0, FontY, 60);
  104.   ng.ng_GadgetID = GD_ActionLV;
  105.  
  106.   g = CreateGadget (LISTVIEW_KIND, g, &ng, GTLV_Labels, AL, TAG_DONE);
  107.  
  108.   ActionGadgets[1] = g;
  109.  
  110.   ng.ng_TopEdge = compute (OffY, FontY, 78);
  111.   ng.ng_Height = compute ((UWORD) 0, FontY, 13);
  112.   ng.ng_GadgetText = (UBYTE *) "_Info";
  113.   ng.ng_GadgetID = GD_FInfo;
  114.   ng.ng_Flags = PLACETEXT_IN;
  115.  
  116.   g = CreateGadget (BUTTON_KIND, g, &ng, GT_Underscore, '_', TAG_DONE);
  117.  
  118.   ActionGadgets[2] = g;
  119.  
  120.   /*
  121.    * Falls es sich nicht um die letzte Datei handelt,
  122.    * wird ein weiteres Gadget eingebunden.
  123.    */
  124.   if (NOT (last))
  125.     {
  126.       ng.ng_TopEdge = compute (OffY, FontY, 92);
  127.       ng.ng_GadgetText = (UBYTE *) "Next Entry";
  128.       ng.ng_GadgetID = GD_NextEntryGad;
  129.  
  130.       g = CreateGadget (BUTTON_KIND, g, &ng, TAG_DONE);
  131.  
  132.       ActionGadgets[3] = g;
  133.     }
  134.  
  135.   if (NOT g)
  136.     return (2L);
  137.  
  138.   /*
  139.    * Das Fenster wird mit den entsprechenden
  140.    * Attributen versehen geöffnet.
  141.    */
  142.   if (NOT (ActionWnd = OpenWindowTags (NULL,
  143.                        WA_Left, wleft,
  144.                        WA_Top, wtop,
  145.                        WA_Width, ww,
  146.                        WA_Height, wh,
  147.                        WA_IDCMP, TEXTIDCMP | LISTVIEWIDCMP |
  148.                        IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE |
  149.                        IDCMP_CLOSEWINDOW |
  150.                        IDCMP_REFRESHWINDOW | VANILLAKEY,
  151.                  WA_Flags, WFLG_DRAGBAR | WFLG_DEPTHGADGET |
  152.                      WFLG_CLOSEGADGET | WFLG_SMART_REFRESH |
  153.                        WFLG_RMBTRAP | WFLG_ACTIVATE,
  154.                        WA_Title, ActionWdt,
  155.                     WA_PubScreenName, (UBYTE *) "Workbench",
  156.                        TAG_DONE)))
  157.     return 4L;
  158.  
  159.   RefreshRastPort (ActionWnd, ActionGadgets, gl, 2, FALSE, ActionGList);
  160.  
  161.   return NULL;
  162. }
  163.  
  164.  /*
  165.   * Diese Procedure erzeugt ein Listenelement in der
  166.   * Aktionsliste. Dazu wird eine eingelesene Zeile mit
  167.   * der C-Library-Funktion strtok() in einzelne Teile
  168.   * zerlegt, die durch ein '#' getrennt sind.
  169.   */
  170. static void
  171. BuildActionEntry (UBYTE * line, RSYS_acts * Act)
  172. {
  173.   /*
  174.    * Die Token für den weiteren Duchlauf
  175.    * initialisieren.
  176.    */
  177.   char *token = strtok ((char *) line, ACTION_TOKEN);
  178.  
  179.   /*
  180.    * Der Listenknoten wird gemäß der C=-Richtlinien
  181.    * initialisiert.
  182.    */
  183.   Act->act_Node.ln_Pri = 0;
  184.   Act->act_Node.ln_Type = NT_USER;
  185.   Act->act_Node.ln_Name = Act->act_name;
  186.  
  187.   /*
  188.    * Das  erste       Token  enthält  die Dateitypnummer des
  189.    * entsprechenden Eintrags, die auch der intern
  190.    * verwendeten Nummer entspricht.
  191.    */
  192.   Act->act_filetype = atoi (token);
  193.  
  194.   /*
  195.    * Dieses Token enthält den Dateityp als String, der
  196.    * in dem Textgadget über dem ListView erscheint.
  197.    */
  198.   token = strtok (STRINGEND, ACTION_TOKEN);
  199.   strcpy (Act->act_listviewheader, token);
  200.  
  201.   /*
  202.    * Dieser Token enthält die Aktionsbezeichnung, die
  203.    * in dem ListView angezeigt wird.
  204.    */
  205.   token = strtok (STRINGEND, ACTION_TOKEN);
  206.   strcpy (Act->act_name, token);
  207.  
  208.   /*
  209.    * Dieser Token enthält die Aktion, die nach der
  210.    * Anwahl des entsprechenden ListView-Eintrags
  211.    * ausgeführt wird.
  212.    */
  213.   token = strtok (STRINGEND, ACTION_TOKEN);
  214.   strcpy (Act->act_command, token);
  215.  
  216.   /*
  217.    * Das Prioritätsfeld des Knotens in der
  218.    * Actions-Struktur mißbrauchen wir als Flag, das
  219.    * festlegt, ob nach dieser Aktion das Action-Fenster
  220.    * geschlossen werden soll oder nicht.
  221.    */
  222.   token = strtok (STRINGEND, ACTION_TOKEN);
  223.   Act->act_Node.ln_Pri = (*token == 'W') ? 1 : 0;
  224.  
  225.   return;
  226. }
  227.  
  228.  /*
  229.   * Die Funktion BuildActionList() holt aus der
  230.   * Environmentvariablen SYSACTION die
  231.   * Bezeichnung der Datei, die die Aktionen für die
  232.   * einzelnen Dateitypen enthält und baut aus den
  233.   * Inhalten dieser Datei eine Liste auf.
  234.   */
  235. void
  236. BuildActionList (void)
  237. {
  238.   BPTR actfile;
  239.   int i = 0;
  240.   UBYTE *line, *buf;
  241.  
  242.   HandleHelp (MN_ReloadActionFile);
  243.  
  244.   DPOS;
  245.  
  246.   if (!ChooseNewFile ((char *) RSysFiles.ActionFile, "Select new Action file..."))
  247.     return;
  248.  
  249.   /*
  250.    * Falls bereits zuvor die Datei gelesen und eine
  251.    * Liste aufgebaut wurde, wird der Speicher jetzt
  252.    * freigegeben und der Zeiger initialisiert.
  253.    */
  254.   MyFreeVec (Actions);
  255.   Actions = NULL;
  256.  
  257.   if ((line = MyAllocVec ((MAXLINESIZE + 1) * sizeof (UBYTE), MEMF_CLEAR, NO_KILL)) &&
  258.       (actfile = Open (RSysFiles.ActionFile, MODE_OLDFILE)))
  259.     {
  260.       /*
  261.        * Der erste Eintrag in der Datei enthält die Anzahl
  262.        * der eingetragenen Aktionen.
  263.        */
  264.       FGets (actfile, line, MAXLINESIZE);
  265.       counter = atoi ((char *) line);
  266.  
  267.       /*
  268.        * Falls der Eintrag keine gültige Zahl war, lieferte
  269.        * atoi() den Wert 0 zurück.      In diesem Falle wird
  270.        * das Unterprogramm mit dem Schließen der Datei und
  271.        * einer Fehlermeldung abgebrochen.
  272.        */
  273.       if (!counter)
  274.     {
  275.       Close (actfile);
  276.       MyFreeVec (line);
  277.       ErrorHandle ((char *) RSysFiles.ActionFile, FILE_ERR, WRONG_FAIL, NO_KILL);
  278.       return;
  279.     }
  280.  
  281.       /*
  282.        * Für die Liste wird entsprechend der Anzahl der
  283.        * Einträge Speicherplatz besorgt.
  284.        */
  285.       Actions = MyAllocVec (counter * sizeof (RSYS_acts), MEMF_CLEAR, NO_KILL);
  286.  
  287.       if (Actions)
  288.     {
  289.       /*
  290.        * Die Action-Liste wird aktualisiert.
  291.        */
  292.       NewList (&ActionList);
  293.  
  294.       /*
  295.        * Die erste Zeile wird gelesen.
  296.        */
  297.       buf = FGets (actfile, line, MAXLINESIZE);
  298.  
  299.       /*
  300.        * In dieser Zeile werden alle Aktionen eingelesen
  301.        * und die Liste aufgebaut.
  302.        */
  303.       for (i = 0; (i < counter) && buf; i++)
  304.         {
  305.           BuildActionEntry (line, &Actions[i]);
  306.  
  307.           AddTail (&ActionList, &Actions[i].act_Node);
  308.           buf = FGets (actfile, line, MAXLINESIZE);
  309.         }
  310.  
  311.       /*
  312.        * Falls ein Fehler beim Lesen auftrat oder weniger
  313.        * Zeilen in der Datei waren, als counter angibt,
  314.        * wird eine Fehlermeldung erzeugt.
  315.        */
  316.       if (!buf && IoErr ())
  317.         ErrorHandle ((char *) RSysFiles.ActionFile, FILE_ERR, READ_FAIL, NO_KILL);
  318.     }
  319.  
  320.       /*
  321.        * Die Datei wird nach dem Auslesen geschlossen.
  322.        */
  323.       Close (actfile);
  324.  
  325.       MyFreeVec (line);
  326.  
  327.       return;
  328.     }
  329.  
  330.   return;
  331. }
  332.  
  333.  /*
  334.   * Die Prozedur ShowInfo() zeigt entsprechend des
  335.   * Dateityps Directory, Device oder File eine Info
  336.   * in Form eines Systemrequesters.
  337.   */
  338. static void
  339. ShowInfo (char *file)
  340. {
  341.   APTR req;
  342.   RSYS_Objid obj;
  343.  
  344.   /*
  345.    * Das Actionwindow wird mit einem unsichtbaren
  346.    * Requester gegen Eingaben geschützt, während die
  347.    * Anzeige aktiv ist.
  348.    */
  349.   req = LockWindow (ActionWnd);
  350.  
  351.   /*
  352.    * Entsprechend des letzten Zeichens der Datei wird
  353.    * entschieden, ob es sich um ein Device, ein
  354.    * Verzeichnis oder eine Datei handelt.
  355.    */
  356.   switch (file[strlen (file) - 1])
  357.     {
  358.       /*
  359.        * Die Datei ist eine Disk. Auf Wunsch wird eine
  360.        * Verzeichnisstruktur dieser Disk gezeigt.
  361.        */
  362.     case ':':
  363.       if (DisplayDiskInfo (file, TRUE))
  364.     {
  365.       strcpy (obj.fullname, file);
  366.       PrintTree (&obj);
  367.     }
  368.       break;
  369.  
  370.       /*
  371.        * Die Datei ist ein Verzeichnis.  Auf Wunsch wird
  372.        * eine Verzeichnisstruktur diese Verzeichnisses
  373.        * gezeigt.
  374.        */
  375.     case '/':
  376.       DisplayDirectoryInfo (file);
  377.       break;
  378.  
  379.       /*
  380.        * Ist jedem anderen Fall wird eine allgemeine
  381.        * Fileinfo angezeigt. Die Routine PrintHunkStruct()
  382.        * entscheidet außerdem, ob es ein Executable ist und
  383.        * bietet entsprechend die Möglichkeit an, ein
  384.        * Hunklisting zu erzeugen.
  385.        */
  386.     default:
  387.       if (filetype (file) == TYPE_EXECUTABLE)
  388.     {
  389.       if (DisplayFileInfo (file))
  390.         PrintHunkStruct (file);
  391.     }
  392.       else
  393.     DisplayFileInfo (file);
  394.  
  395.       break;
  396.     }
  397.  
  398.   /*
  399.    * Das Actionwindow wird wieder freigegeben.
  400.    */
  401.   UnlockWindow (req);
  402.  
  403.   return;
  404. }
  405.  
  406.  /*
  407.   * Die Funktion StartAction() baut eine Teilliste für
  408.   * den entsprechenden Dateitypen auf und präsentiert
  409.   * ein Fenster mit drei oder vier Gadgets. Wenn last
  410.   * TRUE ist, handelt es sich um die letzte oder nur
  411.   * eine Datei. Andernfalls wurden mehrere Gadgets
  412.   * über das AppIcon von RSys gezogen und es erscheint
  413.   * ein viertes Gadget "Next".
  414.   */
  415. int
  416. StartAction (int ftype, char *file, BOOL last)
  417. {
  418.   INTUIMESSAGE *message;
  419.   ULONG class, code;
  420.   APTR object;
  421.   ULONG mask;
  422.   NODE *node = NULL;
  423.   RSYS_acts *act = NULL;
  424.   int GID, cnt = 0, j, ret = TRUE, new;
  425.   UBYTE *basename = FilePart ((UBYTE *) file);
  426.   UBYTE *dirname = PathPart ((UBYTE *) file);
  427.  
  428.   DPOS;
  429.  
  430.   Flags.quit_action_flag = 0;
  431.   /*
  432.    * Initialisierung der Anzeigeliste.
  433.    */
  434.   NewList (&DL);
  435.  
  436.   /*
  437.    * Die Actions, die dem Filetypen entsprechen, werden
  438.    * gezählt.
  439.    */
  440.   for (j = 0; j < counter; j++)
  441.     if (Actions[j].act_filetype == ftype)
  442.       cnt++;
  443.  
  444.   /*
  445.    * Falls Actionen gefunden wurden...
  446.    */
  447.   if (cnt)
  448.     {
  449.       /*
  450.        * ...wird entsprechend Speicher besorgt.
  451.        */
  452.       act = MyAllocVec ((cnt + 1) * sizeof (RSYS_acts), MEMF_CLEAR, NO_KILL);
  453.  
  454.       /*
  455.        * Das Unterprogramm wird verlassen, falls nicht
  456.        * genügend Speicher reserviert werden konnte.
  457.        */
  458.       if (NOT (act))
  459.     return FALSE;
  460.  
  461.       /*
  462.        * Der Zähler für die Teilliste wird initialisiert.
  463.        */
  464.       new = 0;
  465.  
  466.       /*
  467.        * Die neue Displayliste wird aufgebaut und die
  468.        * Einträge gezählt.
  469.        */
  470.       for (j = 0; (j < counter) && (new < cnt); j++)
  471.     if (Actions[j].act_filetype == ftype)
  472.       {
  473.         CopyMem ((APTR) & Actions[j], (APTR) & act[new], sizeof (RSYS_acts));
  474.         AddTail (&DL, &act[new++].act_Node);
  475.       }
  476.     }
  477.  
  478.   /*
  479.      * Falls die Datei kein Verzeichnis ist, wird für den
  480.      * Windowtitle der Basisname der Datei gebildet, also
  481.      * Filename ohne Pfad.
  482.    */
  483.   if (ftype != TYPE_DIR)
  484.     strncpy ((char *) ActionWdt, (char *) basename, 13);
  485.   else
  486.     {
  487.       /*
  488.        * Falls es ein Verzeichnis ist, werden maximal 13
  489.        * Zeichen des Strings für die Titelzeile kopiert.
  490.        */
  491.       int dirlen = MIN (13, ((char *) dirname - (char *) file));
  492.  
  493.       strncpy ((char *) ActionWdt, (char *) file, dirlen);
  494.  
  495.       ActionWdt[dirlen] = STRINGEND;
  496.     }
  497.  
  498.   /*
  499.    * Die Bildschirmattribute werden bestimmt und das
  500.    * Actionwindow geöffnet.
  501.    */
  502.   if (!SetupScreen () && !OpenActionWindow (&DL, last))
  503.     {
  504.       /*
  505.        * Der Dateityp wird in das Textgadget eingetragen.
  506.        */
  507.       GT_SetGadgetAttrs (ActionGadgets[GD_FileTypeTGad - GD_FileTypeTGad], ActionWnd,
  508.              NULL,
  509.              GTTX_Text, mess[ftype],
  510.              TAG_DONE);
  511.  
  512.       do
  513.     {
  514.       /*
  515.        * Es wird auf ein ^C oder ein Signal vom
  516.        * Actionwindow gewartet.
  517.        */
  518.       mask = Wait (SIGBREAKF_CTRL_C | (1L << ActionWnd->UserPort->mp_SigBit));
  519.  
  520.       /*
  521.        * Falls ein ^C erkannt wurde, wird das Actioning
  522.        * beendet.
  523.        */
  524.       if (mask & SIGBREAKF_CTRL_C)
  525.         Flags.quit_action_flag = 1;
  526.  
  527.       /*
  528.        * Es ist eine Nachricht am Userport des
  529.        * Actionwindows eingetroffen.
  530.        */
  531.       if (mask & (1L << ActionWnd->UserPort->mp_SigBit))
  532.         while ((message = (INTUIMESSAGE *) GT_GetIMsg (ActionWnd->UserPort)) != NULL)
  533.           {
  534.         /*
  535.          * Die notwendigen Daten werden aus der
  536.          * Message-Struktur kopiert.
  537.          */
  538.         object = message->IAddress;
  539.         class = message->Class;
  540.         code = message->Code;
  541.  
  542.         /*
  543.          * Damit Intuition nicht wartet, wird die Nachricht
  544.          * sofort beantwortet.
  545.          */
  546.         GT_ReplyIMsg (message);
  547.  
  548.         switch (class)
  549.           {
  550.             /*
  551.              * Falls ein angeklicktes Gadget losgelassen wurde,
  552.              * wird entsprechend der GadgetID eine Aktion
  553.              * gestartet.
  554.              */
  555.           case IDCMP_GADGETUP:
  556.             GID = ((GADGET *) object)->GadgetID;
  557.  
  558.             HandleHelp ((enum RSysNumbers) GID);
  559.  
  560.             switch (GID)
  561.               {
  562.             /*
  563.              * Falls es sich nicht um die letzte Datei handelt,
  564.              * wird das Unterprogramm beendet, wenn das
  565.              * "Next"-Gadget geklickt wird.
  566.              */
  567.               case GD_NextEntryGad:
  568.             if (NOT (last))
  569.               {
  570.                 Flags.quit_action_flag = 1;
  571.                 node = NULL;
  572.               }
  573.             break;
  574.  
  575.             /*
  576.              * Falls das "Info"-Gadget geklickt wurde, wird eine
  577.              * Info in Form eines Systemrequesters angezeigt.
  578.              * Falls es zu diesem Dateityp keine Aktionen gibt,
  579.              * die Liste DL also leer ist, wird das Unterprogramm
  580.              * beendet. Zuvor wird dann der MessagePort des
  581.              * ActionWindows geleert.
  582.              */
  583.               case GD_FInfo:
  584.             ShowInfo (file);
  585.             node = NULL;
  586.  
  587.             if (IsListEmpty (&DL))
  588.               {
  589.                 ClearIntuiMsgPort (ActionWnd);
  590.                 Flags.quit_action_flag = 1;
  591.               }
  592.             break;
  593.  
  594.             /*
  595.              * Wenn das ListView angeklickt wurde, wird der
  596.              * angeklickte Eintrag bestimmt, das assozierte
  597.              * Action command ausgeführt und das Unterprogramm
  598.              * zum Beenden vorbereitet, falls nach Aktion das
  599.              * Fenster geschlossen werden soll.
  600.              */
  601.               case GD_ActionLV:
  602.             if (node = GetNode (&DL, code))
  603.               Command (node, file);
  604.  
  605.             if (node->ln_Pri == 0)
  606.               {
  607.                 ClearIntuiMsgPort (ActionWnd);
  608.                 Flags.quit_action_flag = 1;
  609.               }
  610.             else
  611.               node = NULL;
  612.             break;
  613.               }
  614.             break;
  615.  
  616.             /*
  617.              * Falls eine Taste betätigt wurde, wird diese
  618.              * ermittelt und verarbeitet.
  619.              */
  620.           case IDCMP_VANILLAKEY:
  621.             switch (code)
  622.               {
  623.             /*
  624.              * Diese Tasten entsprechen dem Anklicken des
  625.              * "Info"-Gadgets.
  626.              */
  627.               case 'i':
  628.               case 'I':
  629.             HandleHelp ((enum RSysNumbers) GD_FInfo);
  630.  
  631.             ShowInfo (file);
  632.             node = NULL;
  633.             break;
  634.  
  635.             /*
  636.              * Diese Tasten entsprechen dem Anklicken des
  637.              * Closegadgets des Action windows..
  638.              */
  639.               case ESC:
  640.             Flags.quit_action_flag = 1;
  641.             ret = FALSE;
  642.             node = NULL;
  643.             break;
  644.               }
  645.             break;
  646.  
  647.             /*
  648.              * Das Fenster wird zum Beenden des Unterprogrammes
  649.              * vorbereitet.
  650.              */
  651.           case IDCMP_CLOSEWINDOW:
  652.             Flags.quit_action_flag = 1;
  653.             ret = FALSE;
  654.             node = NULL;
  655.             break;
  656.           }
  657.           }
  658.     }
  659.       while (NOT (Flags.quit_action_flag));
  660.  
  661.       /*
  662.        * Das Action window wird geschlossen und der
  663.        * PublicScreen freigegeben.
  664.        */
  665.       CloseASysWindow (&ActionWnd, &ActionGList, NULL);
  666.       CloseDownScreen ();
  667.     }
  668.   else
  669.     ErrorHandle ("SetupScreen()", WINDOW_ERR, OPEN_FAIL, NO_KILL);
  670.  
  671.   /*
  672.    * Der Speicher, der für die Liste der Aktionen
  673.    * angelegt wurde, wird freigegeben.
  674.    */
  675.   MyFreeVec (act);
  676.  
  677.   return ret;
  678. }
  679.  
  680. void
  681. DisplayFileRequest (void)
  682. {
  683.   static char dir[MAXFULLNAME] = "RAM:", file[MAXFULLNAME] = "unknown";
  684.  
  685.   DisableSysRequest (TRUE);
  686.  
  687.   if (GetFile (SysWnd, dir, file, "#?", "Choose File for ClipBoard...", "Clip it"))
  688.     {
  689.       strncpy (file, (char *) FilePart ((STRPTR) _fullpath), MAXFULLNAME);
  690.       strncpy (dir, (char *) _fullpath, (int) ((ULONG) PathPart ((STRPTR) _fullpath) - (ULONG) _fullpath));
  691.  
  692.       SaveListToClip (NULL, _fullpath);
  693.     }
  694.  
  695.   DisableSysRequest (FALSE);
  696.  
  697.   return;
  698. }
  699.